/*
 * FreeRTOS Kernel V10.4.6
 * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.    All Rights Reserved.
 *
 * SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * https://www.FreeRTOS.org
 * https://github.com/FreeRTOS
 *
 */

/* Standard includes. */
#include <stdlib.h>

/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
 * all the API functions to use the MPU wrappers.    That should only be done when
 * task.h is included from an application file. */
#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE

#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "timers.h"

#if ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 0 )
        #error configUSE_TIMERS must be set to 1 to make the xTimerPendFunctionCall() function available.
#endif

/* Lint e9021, e961 and e750 are suppressed as a MISRA exception justified
 * because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined
 * for the header files above, but not in this file, in order to generate the
 * correct privileged Vs unprivileged linkage and placement. */
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e9021 !e961 !e750. */


/* This entire source file will be skipped if the application is not configured
 * to include software timer functionality.    This #if is closed at the very bottom
 * of this file.    If you want to include software timer functionality then ensure
 * configUSE_TIMERS is set to 1 in FreeRTOSConfig.h. */
#if ( configUSE_TIMERS == 1 )

/* Misc definitions. */
        #define tmrNO_DELAY                                        ( ( TickType_t ) 0U )
        #define tmrMAX_TIME_BEFORE_OVERFLOW        ( ( TickType_t ) -1 )

/* The name assigned to the timer service task.    This can be overridden by
 * defining trmTIMER_SERVICE_TASK_NAME in FreeRTOSConfig.h. */
        #ifndef configTIMER_SERVICE_TASK_NAME
                #define configTIMER_SERVICE_TASK_NAME        "Tmr Svc"
        #endif

/* Bit definitions used in the ucStatus member of a timer structure. */
        #define tmrSTATUS_IS_ACTIVE                                    ( ( uint8_t ) 0x01 )
        #define tmrSTATUS_IS_STATICALLY_ALLOCATED        ( ( uint8_t ) 0x02 )
        #define tmrSTATUS_IS_AUTORELOAD                            ( ( uint8_t ) 0x04 )

/* The definition of the timers themselves. */
        typedef struct tmrTimerControl                                    /* The old naming convention is used to prevent breaking kernel aware debuggers. */
        {
                const char * pcTimerName;                                     /*<< Text name.    This is not used by the kernel, it is included simply to make debugging easier. */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
                ListItem_t xTimerListItem;                                    /*<< Standard linked list item as used by all kernel features for event management. */
                TickType_t xTimerPeriodInTicks;                         /*<< How quickly and often the timer expires. */
                void * pvTimerID;                                                     /*<< An ID to identify the timer.    This allows the timer to be identified when the same callback is used for multiple timers. */
                TimerCallbackFunction_t pxCallbackFunction; /*<< The function that will be called when the timer expires. */
                #if ( configUSE_TRACE_FACILITY == 1 )
                        UBaseType_t uxTimerNumber;                            /*<< An ID assigned by trace tools such as FreeRTOS+Trace */
                #endif
                uint8_t ucStatus;                                                     /*<< Holds bits to say if the timer was statically allocated or not, and if it is active or not. */
        } xTIMER;

/* The old xTIMER name is maintained above then typedefed to the new Timer_t
 * name below to enable the use of older kernel aware debuggers. */
        typedef xTIMER Timer_t;

/* The definition of messages that can be sent and received on the timer queue.
 * Two types of message can be queued - messages that manipulate a software timer,
 * and messages that request the execution of a non-timer related callback.    The
 * two message types are defined in two separate structures, xTimerParametersType
 * and xCallbackParametersType respectively. */
        typedef struct tmrTimerParameters
        {
                TickType_t xMessageValue; /*<< An optional value used by a subset of commands, for example, when changing the period of a timer. */
                Timer_t * pxTimer;                /*<< The timer to which the command will be applied. */
        } TimerParameter_t;


        typedef struct tmrCallbackParameters
        {
                PendedFunction_t pxCallbackFunction; /* << The callback function to execute. */
                void * pvParameter1;                                 /* << The value that will be used as the callback functions first parameter. */
                uint32_t ulParameter2;                             /* << The value that will be used as the callback functions second parameter. */
        } CallbackParameters_t;

/* The structure that contains the two message types, along with an identifier
 * that is used to determine which message type is valid. */
        typedef struct tmrTimerQueueMessage
        {
                BaseType_t xMessageID; /*<< The command being sent to the timer service task. */
                union
                {
                        TimerParameter_t xTimerParameters;

                        /* Don't include xCallbackParameters if it is not going to be used as
                         * it makes the structure (and therefore the timer queue) larger. */
                        #if ( INCLUDE_xTimerPendFunctionCall == 1 )
                                CallbackParameters_t xCallbackParameters;
                        #endif /* INCLUDE_xTimerPendFunctionCall */
                } u;
        } DaemonTaskMessage_t;

/*lint -save -e956 A manual analysis and inspection has been used to determine
 * which static variables must be declared volatile. */

/* The list in which active timers are stored.    Timers are referenced in expire
 * time order, with the nearest expiry time at the front of the list.    Only the
 * timer service task is allowed to access these lists.
 * xActiveTimerList1 and xActiveTimerList2 could be at function scope but that
 * breaks some kernel aware debuggers, and debuggers that reply on removing the
 * static qualifier. */
        PRIVILEGED_DATA static List_t xActiveTimerList1;
        PRIVILEGED_DATA static List_t xActiveTimerList2;
        PRIVILEGED_DATA static List_t * pxCurrentTimerList;
        PRIVILEGED_DATA static List_t * pxOverflowTimerList;

/* A queue that is used to send commands to the timer service task. */
        PRIVILEGED_DATA static QueueHandle_t xTimerQueue = NULL;
        PRIVILEGED_DATA static TaskHandle_t xTimerTaskHandle = NULL;

/*lint -restore */

/*-----------------------------------------------------------*/

/*
 * Initialise the infrastructure used by the timer service task if it has not
 * been initialised already.
 */
        static void prvCheckForValidListAndQueue( void ) PRIVILEGED_FUNCTION;

/*
 * The timer service task (daemon).    Timer functionality is controlled by this
 * task.    Other tasks communicate with the timer service task using the
 * xTimerQueue queue.
 */
        static portTASK_FUNCTION_PROTO( prvTimerTask, pvParameters ) PRIVILEGED_FUNCTION;

/*
 * Called by the timer service task to interpret and process a command it
 * received on the timer queue.
 */
        static void prvProcessReceivedCommands( void ) PRIVILEGED_FUNCTION;

/*
 * Insert the timer into either xActiveTimerList1, or xActiveTimerList2,
 * depending on if the expire time causes a timer counter overflow.
 */
        static BaseType_t prvInsertTimerInActiveList( Timer_t * const pxTimer,
                                                                                                    const TickType_t xNextExpiryTime,
                                                                                                    const TickType_t xTimeNow,
                                                                                                    const TickType_t xCommandTime ) PRIVILEGED_FUNCTION;

/*
 * Reload the specified auto-reload timer.    If the reloading is backlogged,
 * clear the backlog, calling the callback for each additional reload.    When
 * this function returns, the next expiry time is after xTimeNow.
 */
        static void prvReloadTimer( Timer_t * const pxTimer,
                                                                TickType_t xExpiredTime,
                                                                const TickType_t xTimeNow ) PRIVILEGED_FUNCTION;

/*
 * An active timer has reached its expire time.    Reload the timer if it is an
 * auto-reload timer, then call its callback.
 */
        static void prvProcessExpiredTimer( const TickType_t xNextExpireTime,
                                                                                const TickType_t xTimeNow ) PRIVILEGED_FUNCTION;

/*
 * The tick count has overflowed.    Switch the timer lists after ensuring the
 * current timer list does not still reference some timers.
 */
        static void prvSwitchTimerLists( void ) PRIVILEGED_FUNCTION;

/*
 * Obtain the current tick count, setting *pxTimerListsWereSwitched to pdTRUE
 * if a tick count overflow occurred since prvSampleTimeNow() was last called.
 */
        static TickType_t prvSampleTimeNow( BaseType_t * const pxTimerListsWereSwitched ) PRIVILEGED_FUNCTION;

/*
 * If the timer list contains any active timers then return the expire time of
 * the timer that will expire first and set *pxListWasEmpty to false.    If the
 * timer list does not contain any timers then return 0 and set *pxListWasEmpty
 * to pdTRUE.
 */
        static TickType_t prvGetNextExpireTime( BaseType_t * const pxListWasEmpty ) PRIVILEGED_FUNCTION;

/*
 * If a timer has expired, process it.    Otherwise, block the timer service task
 * until either a timer does expire or a command is received.
 */
        static void prvProcessTimerOrBlockTask( const TickType_t xNextExpireTime,
                                                                                        BaseType_t xListWasEmpty ) PRIVILEGED_FUNCTION;

/*
 * Called after a Timer_t structure has been allocated either statically or
 * dynamically to fill in the structure's members.
 */
        static void prvInitialiseNewTimer( const char * const pcTimerName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
                                                                             const TickType_t xTimerPeriodInTicks,
                                                                             const UBaseType_t uxAutoReload,
                                                                             void * const pvTimerID,
                                                                             TimerCallbackFunction_t pxCallbackFunction,
                                                                             Timer_t * pxNewTimer ) PRIVILEGED_FUNCTION;
/*-----------------------------------------------------------*/

        BaseType_t xTimerCreateTimerTask( void )
        {
                BaseType_t xReturn = pdFAIL;

                /* This function is called when the scheduler is started if
                 * configUSE_TIMERS is set to 1.    Check that the infrastructure used by the
                 * timer service task has been created/initialised.    If timers have already
                 * been created then the initialisation will already have been performed. */
                prvCheckForValidListAndQueue();

                if( xTimerQueue != NULL )
                {
                        #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
                                {
                                        StaticTask_t * pxTimerTaskTCBBuffer = NULL;
                                        StackType_t * pxTimerTaskStackBuffer = NULL;
                                        uint32_t ulTimerTaskStackSize;

                                        vApplicationGetTimerTaskMemory( &pxTimerTaskTCBBuffer, &pxTimerTaskStackBuffer, &ulTimerTaskStackSize );
                                        xTimerTaskHandle = xTaskCreateStatic( prvTimerTask,
                                                                                                                    configTIMER_SERVICE_TASK_NAME,
                                                                                                                    ulTimerTaskStackSize,
                                                                                                                    NULL,
                                                                                                                    ( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT,
                                                                                                                    pxTimerTaskStackBuffer,
                                                                                                                    pxTimerTaskTCBBuffer );

                                        if( xTimerTaskHandle != NULL )
                                        {
                                                xReturn = pdPASS;
                                        }
                                }
                        #else /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
                                {
                                        xReturn = xTaskCreate( prvTimerTask,
                                                                                     configTIMER_SERVICE_TASK_NAME,
                                                                                     configTIMER_TASK_STACK_DEPTH,
                                                                                     NULL,
                                                                                     ( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT,
                                                                                     &xTimerTaskHandle );
                                }
                        #endif /* configSUPPORT_STATIC_ALLOCATION */
                }
                else
                {
                        mtCOVERAGE_TEST_MARKER();
                }

                configASSERT( xReturn );
                return xReturn;
        }
/*-----------------------------------------------------------*/

        #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

                TimerHandle_t xTimerCreate( const char * const pcTimerName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
                                                                        const TickType_t xTimerPeriodInTicks,
                                                                        const UBaseType_t uxAutoReload,
                                                                        void * const pvTimerID,
                                                                        TimerCallbackFunction_t pxCallbackFunction )
                {
                        extern void rqd_tmrCreateHook(Timer_t * tmr);
                        Timer_t * pxNewTimer;

                        pxNewTimer = ( Timer_t * ) pvPortMalloc( sizeof( Timer_t ) ); /*lint !e9087 !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack, and the first member of Timer_t is always a pointer to the timer's mame. */

                        if( pxNewTimer != NULL )
                        {
                                /* Status is thus far zero as the timer is not created statically
                                 * and has not been started.    The auto-reload bit may get set in
                                 * prvInitialiseNewTimer. */
                                pxNewTimer->ucStatus = 0x00;
                                prvInitialiseNewTimer( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxNewTimer );
                        }
                        rqd_tmrCreateHook(pxNewTimer);
                        return pxNewTimer;
                }

        #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
/*-----------------------------------------------------------*/

        #if ( configSUPPORT_STATIC_ALLOCATION == 1 )

                TimerHandle_t xTimerCreateStatic( const char * const pcTimerName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
                                                                                    const TickType_t xTimerPeriodInTicks,
                                                                                    const UBaseType_t uxAutoReload,
                                                                                    void * const pvTimerID,
                                                                                    TimerCallbackFunction_t pxCallbackFunction,
                                                                                    StaticTimer_t * pxTimerBuffer )
                {
                        Timer_t * pxNewTimer;

                        #if ( configASSERT_DEFINED == 1 )
                                {
                                        /* Sanity check that the size of the structure used to declare a
                                         * variable of type StaticTimer_t equals the size of the real timer
                                         * structure. */
                                        volatile size_t xSize = sizeof( StaticTimer_t );
                                        configASSERT( xSize == sizeof( Timer_t ) );
                                        ( void ) xSize; /* Keeps lint quiet when configASSERT() is not defined. */
                                }
                        #endif /* configASSERT_DEFINED */

                        /* A pointer to a StaticTimer_t structure MUST be provided, use it. */
                        configASSERT( pxTimerBuffer );
                        pxNewTimer = ( Timer_t * ) pxTimerBuffer; /*lint !e740 !e9087 StaticTimer_t is a pointer to a Timer_t, so guaranteed to be aligned and sized correctly (checked by an assert()), so this is safe. */

                        if( pxNewTimer != NULL )
                        {
                                /* Timers can be created statically or dynamically so note this
                                 * timer was created statically in case it is later deleted.    The
                                 * auto-reload bit may get set in prvInitialiseNewTimer(). */
                                pxNewTimer->ucStatus = tmrSTATUS_IS_STATICALLY_ALLOCATED;

                                prvInitialiseNewTimer( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxNewTimer );
                        }

                        return pxNewTimer;
                }

        #endif /* configSUPPORT_STATIC_ALLOCATION */
/*-----------------------------------------------------------*/

        static void prvInitialiseNewTimer( const char * const pcTimerName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
                                                                             const TickType_t xTimerPeriodInTicks,
                                                                             const UBaseType_t uxAutoReload,
                                                                             void * const pvTimerID,
                                                                             TimerCallbackFunction_t pxCallbackFunction,
                                                                             Timer_t * pxNewTimer )
        {
                /* 0 is not a valid value for xTimerPeriodInTicks. */
                configASSERT( ( xTimerPeriodInTicks > 0 ) );

                /* Ensure the infrastructure used by the timer service task has been
                 * created/initialised. */
                prvCheckForValidListAndQueue();

                /* Initialise the timer structure members using the function
                 * parameters. */
                pxNewTimer->pcTimerName = pcTimerName;
                pxNewTimer->xTimerPeriodInTicks = xTimerPeriodInTicks;
                pxNewTimer->pvTimerID = pvTimerID;
                pxNewTimer->pxCallbackFunction = pxCallbackFunction;
                vListInitialiseItem( &( pxNewTimer->xTimerListItem ) );

                if( uxAutoReload != pdFALSE )
                {
                        pxNewTimer->ucStatus |= tmrSTATUS_IS_AUTORELOAD;
                }

                traceTIMER_CREATE( pxNewTimer );
        }
/*-----------------------------------------------------------*/

        BaseType_t xTimerGenericCommand( TimerHandle_t xTimer,
                                                                         const BaseType_t xCommandID,
                                                                         const TickType_t xOptionalValue,
                                                                         BaseType_t * const pxHigherPriorityTaskWoken,
                                                                         const TickType_t xTicksToWait )
        {
            extern void rqd_hookTmrFuncCall(void* xTimer,const BaseType_t xCommandID);
                BaseType_t xReturn = pdFAIL;
                DaemonTaskMessage_t xMessage;

                configASSERT( xTimer );
                rqd_hookTmrFuncCall( xTimer, xCommandID);
                /* Send a message to the timer service task to perform a particular action
                 * on a particular timer definition. */
                if( xTimerQueue != NULL )
                {
                        /* Send a command to the timer service task to start the xTimer timer. */
                        xMessage.xMessageID = xCommandID;
                        xMessage.u.xTimerParameters.xMessageValue = xOptionalValue;
                        xMessage.u.xTimerParameters.pxTimer = xTimer;

                        if( xCommandID < tmrFIRST_FROM_ISR_COMMAND )
                        {
                                if( xTaskGetSchedulerState() == taskSCHEDULER_RUNNING )
                                {
                                        xReturn = xQueueSendToBack( xTimerQueue, &xMessage, xTicksToWait );
                                }
                                else
                                {
                                        xReturn = xQueueSendToBack( xTimerQueue, &xMessage, tmrNO_DELAY );
                                }
                        }
                        else
                        {
                                xReturn = xQueueSendToBackFromISR( xTimerQueue, &xMessage, pxHigherPriorityTaskWoken );
                        }

                        traceTIMER_COMMAND_SEND( xTimer, xCommandID, xOptionalValue, xReturn );
                }
                else
                {
                        mtCOVERAGE_TEST_MARKER();
                }

                return xReturn;
        }
/*-----------------------------------------------------------*/

        TaskHandle_t xTimerGetTimerDaemonTaskHandle( void )
        {
                /* If xTimerGetTimerDaemonTaskHandle() is called before the scheduler has been
                 * started, then xTimerTaskHandle will be NULL. */
                configASSERT( ( xTimerTaskHandle != NULL ) );
                return xTimerTaskHandle;
        }
/*-----------------------------------------------------------*/

        TickType_t xTimerGetPeriod( TimerHandle_t xTimer )
        {
                Timer_t * pxTimer = xTimer;

                configASSERT( xTimer );
                return pxTimer->xTimerPeriodInTicks;
        }
/*-----------------------------------------------------------*/

        void vTimerSetReloadMode( TimerHandle_t xTimer,
                                                            const UBaseType_t uxAutoReload )
        {
                Timer_t * pxTimer = xTimer;

                configASSERT( xTimer );
                taskENTER_CRITICAL();
                {
                        if( uxAutoReload != pdFALSE )
                        {
                                pxTimer->ucStatus |= tmrSTATUS_IS_AUTORELOAD;
                        }
                        else
                        {
                                pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_AUTORELOAD );
                        }
                }
                taskEXIT_CRITICAL();
        }
/*-----------------------------------------------------------*/

        UBaseType_t uxTimerGetReloadMode( TimerHandle_t xTimer )
        {
                Timer_t * pxTimer = xTimer;
                UBaseType_t uxReturn;

                configASSERT( xTimer );
                taskENTER_CRITICAL();
                {
                        if( ( pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD ) == 0 )
                        {
                                /* Not an auto-reload timer. */
                                uxReturn = ( UBaseType_t ) pdFALSE;
                        }
                        else
                        {
                                /* Is an auto-reload timer. */
                                uxReturn = ( UBaseType_t ) pdTRUE;
                        }
                }
                taskEXIT_CRITICAL();

                return uxReturn;
        }
/*-----------------------------------------------------------*/

        TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer )
        {
                Timer_t * pxTimer = xTimer;
                TickType_t xReturn;

                configASSERT( xTimer );
                xReturn = listGET_LIST_ITEM_VALUE( &( pxTimer->xTimerListItem ) );
                return xReturn;
        }
/*-----------------------------------------------------------*/

        const char * pcTimerGetName( TimerHandle_t xTimer ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
        {
                Timer_t * pxTimer = xTimer;

                configASSERT( xTimer );
                return pxTimer->pcTimerName;
        }
/*-----------------------------------------------------------*/

        static void prvReloadTimer( Timer_t * const pxTimer,
                                                                TickType_t xExpiredTime,
                                                                const TickType_t xTimeNow )
        {
                /* Insert the timer into the appropriate list for the next expiry time.
                 * If the next expiry time has already passed, advance the expiry time,
                 * call the callback function, and try again. */
                while( prvInsertTimerInActiveList( pxTimer, ( xExpiredTime + pxTimer->xTimerPeriodInTicks ), xTimeNow, xExpiredTime ) != pdFALSE )
                {
                        /* Advance the expiry time. */
                        xExpiredTime += pxTimer->xTimerPeriodInTicks;

                        /* Call the timer callback. */
                        traceTIMER_EXPIRED( pxTimer );
                        pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );
                }
        }
/*-----------------------------------------------------------*/

        static void prvProcessExpiredTimer( const TickType_t xNextExpireTime,
                                                                                const TickType_t xTimeNow )
        {
                Timer_t * const pxTimer = ( Timer_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTimerList ); /*lint !e9087 !e9079 void * is used as this macro is used with tasks and co-routines too.    Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */

                /* Remove the timer from the list of active timers.    A check has already
                 * been performed to ensure the list is not empty. */

                ( void ) uxListRemove( &( pxTimer->xTimerListItem ) );

                /* If the timer is an auto-reload timer then calculate the next
                 * expiry time and re-insert the timer in the list of active timers. */
                if( ( pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD ) != 0 )
                {
                        prvReloadTimer( pxTimer, xNextExpireTime, xTimeNow );
                }
                else
                {
                        pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE );
                }

                /* Call the timer callback. */
                traceTIMER_EXPIRED( pxTimer );
                pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );
        }
/*-----------------------------------------------------------*/

        static portTASK_FUNCTION( prvTimerTask, pvParameters )
        {
                TickType_t xNextExpireTime;
                BaseType_t xListWasEmpty;

                /* Just to avoid compiler warnings. */
                ( void ) pvParameters;

                #if ( configUSE_DAEMON_TASK_STARTUP_HOOK == 1 )
                        {
                                extern void vApplicationDaemonTaskStartupHook( void );

                                /* Allow the application writer to execute some code in the context of
                                 * this task at the point the task starts executing.    This is useful if the
                                 * application includes initialisation code that would benefit from
                                 * executing after the scheduler has been started. */
                                vApplicationDaemonTaskStartupHook();
                        }
                #endif /* configUSE_DAEMON_TASK_STARTUP_HOOK */

                for( ; ; )
                {
                        /* Query the timers list to see if it contains any timers, and if so,
                         * obtain the time at which the next timer will expire. */
                        xNextExpireTime = prvGetNextExpireTime( &xListWasEmpty );

                        /* If a timer has expired, process it.    Otherwise, block this task
                         * until either a timer does expire, or a command is received. */
                        prvProcessTimerOrBlockTask( xNextExpireTime, xListWasEmpty );

                        /* Empty the command queue. */
                        prvProcessReceivedCommands();
                }
        }
/*-----------------------------------------------------------*/

        static void prvProcessTimerOrBlockTask( const TickType_t xNextExpireTime,
                                                                                        BaseType_t xListWasEmpty )
        {
                TickType_t xTimeNow;
                BaseType_t xTimerListsWereSwitched;

                vTaskSuspendAll();
                {
                        /* Obtain the time now to make an assessment as to whether the timer
                         * has expired or not.    If obtaining the time causes the lists to switch
                         * then don't process this timer as any timers that remained in the list
                         * when the lists were switched will have been processed within the
                         * prvSampleTimeNow() function. */
                        xTimeNow = prvSampleTimeNow( &xTimerListsWereSwitched );

                        if( xTimerListsWereSwitched == pdFALSE )
                        {
                                /* The tick count has not overflowed, has the timer expired? */
                                if( ( xListWasEmpty == pdFALSE ) && ( xNextExpireTime <= xTimeNow ) )
                                {
                                        ( void ) xTaskResumeAll();
                                        prvProcessExpiredTimer( xNextExpireTime, xTimeNow );
                                }
                                else
                                {
                                        /* The tick count has not overflowed, and the next expire
                                         * time has not been reached yet.    This task should therefore
                                         * block to wait for the next expire time or a command to be
                                         * received - whichever comes first.    The following line cannot
                                         * be reached unless xNextExpireTime > xTimeNow, except in the
                                         * case when the current timer list is empty. */
                                        if( xListWasEmpty != pdFALSE )
                                        {
                                                /* The current timer list is empty - is the overflow list
                                                 * also empty? */
                                                xListWasEmpty = listLIST_IS_EMPTY( pxOverflowTimerList );
                                        }

                                        vQueueWaitForMessageRestricted( xTimerQueue, ( xNextExpireTime - xTimeNow ), xListWasEmpty );

                                        if( xTaskResumeAll() == pdFALSE )
                                        {
                                                /* Yield to wait for either a command to arrive, or the
                                                 * block time to expire.    If a command arrived between the
                                                 * critical section being exited and this yield then the yield
                                                 * will not cause the task to block. */
                                                portYIELD_WITHIN_API();
                                        }
                                        else
                                        {
                                                mtCOVERAGE_TEST_MARKER();
                                        }
                                }
                        }
                        else
                        {
                                ( void ) xTaskResumeAll();
                        }
                }
        }
/*-----------------------------------------------------------*/

        static TickType_t prvGetNextExpireTime( BaseType_t * const pxListWasEmpty )
        {
                TickType_t xNextExpireTime;

                /* Timers are listed in expiry time order, with the head of the list
                 * referencing the task that will expire first.    Obtain the time at which
                 * the timer with the nearest expiry time will expire.    If there are no
                 * active timers then just set the next expire time to 0.    That will cause
                 * this task to unblock when the tick count overflows, at which point the
                 * timer lists will be switched and the next expiry time can be
                 * re-assessed.    */
                *pxListWasEmpty = listLIST_IS_EMPTY( pxCurrentTimerList );

                if( *pxListWasEmpty == pdFALSE )
                {
                        xNextExpireTime = listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxCurrentTimerList );
                }
                else
                {
                        /* Ensure the task unblocks when the tick count rolls over. */
                        xNextExpireTime = ( TickType_t ) 0U;
                }

                return xNextExpireTime;
        }
/*-----------------------------------------------------------*/

        static TickType_t prvSampleTimeNow( BaseType_t * const pxTimerListsWereSwitched )
        {
                TickType_t xTimeNow;
                PRIVILEGED_DATA static TickType_t xLastTime = ( TickType_t ) 0U; /*lint !e956 Variable is only accessible to one task. */

                xTimeNow = xTaskGetTickCount();

                if( xTimeNow < xLastTime )
                {
                        prvSwitchTimerLists();
                        *pxTimerListsWereSwitched = pdTRUE;
                }
                else
                {
                        *pxTimerListsWereSwitched = pdFALSE;
                }

                xLastTime = xTimeNow;

                return xTimeNow;
        }
/*-----------------------------------------------------------*/

        static BaseType_t prvInsertTimerInActiveList( Timer_t * const pxTimer,
                                                                                                    const TickType_t xNextExpiryTime,
                                                                                                    const TickType_t xTimeNow,
                                                                                                    const TickType_t xCommandTime )
        {
                BaseType_t xProcessTimerNow = pdFALSE;

                listSET_LIST_ITEM_VALUE( &( pxTimer->xTimerListItem ), xNextExpiryTime );
                listSET_LIST_ITEM_OWNER( &( pxTimer->xTimerListItem ), pxTimer );

                if( xNextExpiryTime <= xTimeNow )
                {
                        /* Has the expiry time elapsed between the command to start/reset a
                         * timer was issued, and the time the command was processed? */
                        if( ( ( TickType_t ) ( xTimeNow - xCommandTime ) ) >= pxTimer->xTimerPeriodInTicks ) /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
                        {
                                /* The time between a command being issued and the command being
                                 * processed actually exceeds the timers period.    */
                                xProcessTimerNow = pdTRUE;
                        }
                        else
                        {
                                vListInsert( pxOverflowTimerList, &( pxTimer->xTimerListItem ) );
                        }
                }
                else
                {
                        if( ( xTimeNow < xCommandTime ) && ( xNextExpiryTime >= xCommandTime ) )
                        {
                                /* If, since the command was issued, the tick count has overflowed
                                 * but the expiry time has not, then the timer must have already passed
                                 * its expiry time and should be processed immediately. */
                                xProcessTimerNow = pdTRUE;
                        }
                        else
                        {
                                vListInsert( pxCurrentTimerList, &( pxTimer->xTimerListItem ) );
                        }
                }

                return xProcessTimerNow;
        }
/*-----------------------------------------------------------*/

        static void prvProcessReceivedCommands( void )
        {
                DaemonTaskMessage_t xMessage;
                Timer_t * pxTimer;
                BaseType_t xTimerListsWereSwitched;
                TickType_t xTimeNow;

                while( xQueueReceive( xTimerQueue, &xMessage, tmrNO_DELAY ) != pdFAIL ) /*lint !e603 xMessage does not have to be initialised as it is passed out, not in, and it is not used unless xQueueReceive() returns pdTRUE. */
                {
                        #if ( INCLUDE_xTimerPendFunctionCall == 1 )
                                {
                                        /* Negative commands are pended function calls rather than timer
                                         * commands. */
                                        if( xMessage.xMessageID < ( BaseType_t ) 0 )
                                        {
                                                const CallbackParameters_t * const pxCallback = &( xMessage.u.xCallbackParameters );

                                                /* The timer uses the xCallbackParameters member to request a
                                                 * callback be executed.    Check the callback is not NULL. */
                                                configASSERT( pxCallback );

                                                /* Call the function. */
                                                pxCallback->pxCallbackFunction( pxCallback->pvParameter1, pxCallback->ulParameter2 );
                                        }
                                        else
                                        {
                                                mtCOVERAGE_TEST_MARKER();
                                        }
                                }
                        #endif /* INCLUDE_xTimerPendFunctionCall */

                        /* Commands that are positive are timer commands rather than pended
                         * function calls. */
                        if( xMessage.xMessageID >= ( BaseType_t ) 0 )
                        {
                                /* The messages uses the xTimerParameters member to work on a
                                 * software timer. */
                                pxTimer = xMessage.u.xTimerParameters.pxTimer;

                                if( listIS_CONTAINED_WITHIN( NULL, &( pxTimer->xTimerListItem ) ) == pdFALSE ) /*lint !e961. The cast is only redundant when NULL is passed into the macro. */
                                {
                                        /* The timer is in a list, remove it. */
                                        ( void ) uxListRemove( &( pxTimer->xTimerListItem ) );
                                }
                                else
                                {
                                        mtCOVERAGE_TEST_MARKER();
                                }

                                traceTIMER_COMMAND_RECEIVED( pxTimer, xMessage.xMessageID, xMessage.u.xTimerParameters.xMessageValue );

                                /* In this case the xTimerListsWereSwitched parameter is not used, but
                                 *    it must be present in the function call.    prvSampleTimeNow() must be
                                 *    called after the message is received from xTimerQueue so there is no
                                 *    possibility of a higher priority task adding a message to the message
                                 *    queue with a time that is ahead of the timer daemon task (because it
                                 *    pre-empted the timer daemon task after the xTimeNow value was set). */
                                xTimeNow = prvSampleTimeNow( &xTimerListsWereSwitched );

                                switch( xMessage.xMessageID )
                                {
                                        case tmrCOMMAND_START:
                                        case tmrCOMMAND_START_FROM_ISR:
                                        case tmrCOMMAND_RESET:
                                        case tmrCOMMAND_RESET_FROM_ISR:
                                                /* Start or restart a timer. */
                                                pxTimer->ucStatus |= tmrSTATUS_IS_ACTIVE;

                                                if( prvInsertTimerInActiveList( pxTimer, xMessage.u.xTimerParameters.xMessageValue + pxTimer->xTimerPeriodInTicks, xTimeNow, xMessage.u.xTimerParameters.xMessageValue ) != pdFALSE )
                                                {
                                                        /* The timer expired before it was added to the active
                                                         * timer list.    Process it now. */
                                                        if( ( pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD ) != 0 )
                                                        {
                                                                prvReloadTimer( pxTimer, xMessage.u.xTimerParameters.xMessageValue + pxTimer->xTimerPeriodInTicks, xTimeNow );
                                                        }
                                                        else
                                                        {
                                                                pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE );
                                                        }

                                                        /* Call the timer callback. */
                                                        traceTIMER_EXPIRED( pxTimer );
                                                        pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );
                                                }
                                                else
                                                {
                                                        mtCOVERAGE_TEST_MARKER();
                                                }

                                                break;

                                        case tmrCOMMAND_STOP:
                                        case tmrCOMMAND_STOP_FROM_ISR:
                                                /* The timer has already been removed from the active list. */
                                                pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE );
                                                break;

                                        case tmrCOMMAND_CHANGE_PERIOD:
                                        case tmrCOMMAND_CHANGE_PERIOD_FROM_ISR:
                                                pxTimer->ucStatus |= tmrSTATUS_IS_ACTIVE;
                                                pxTimer->xTimerPeriodInTicks = xMessage.u.xTimerParameters.xMessageValue;
                                                configASSERT( ( pxTimer->xTimerPeriodInTicks > 0 ) );

                                                /* The new period does not really have a reference, and can
                                                 * be longer or shorter than the old one.    The command time is
                                                 * therefore set to the current time, and as the period cannot
                                                 * be zero the next expiry time can only be in the future,
                                                 * meaning (unlike for the xTimerStart() case above) there is
                                                 * no fail case that needs to be handled here. */
                                                ( void ) prvInsertTimerInActiveList( pxTimer, ( xTimeNow + pxTimer->xTimerPeriodInTicks ), xTimeNow, xTimeNow );
                                                break;

                                        case tmrCOMMAND_DELETE:
                                                #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
                                                        {
                                                                /* The timer has already been removed from the active list,
                                                                 * just free up the memory if the memory was dynamically
                                                                 * allocated. */
                                                                if( ( pxTimer->ucStatus & tmrSTATUS_IS_STATICALLY_ALLOCATED ) == ( uint8_t ) 0 )
                                                                {
                                                                        vPortFree( pxTimer );
                                                                }
                                                                else
                                                                {
                                                                        pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE );
                                                                }
                                                        }
                                                #else /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */
                                                        {
                                                                /* If dynamic allocation is not enabled, the memory
                                                                 * could not have been dynamically allocated. So there is
                                                                 * no need to free the memory - just mark the timer as
                                                                 * "not active". */
                                                                pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE );
                                                        }
                                                #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
                                                break;

                                        default:
                                                /* Don't expect to get here. */
                                                break;
                                }
                        }
                }
        }
/*-----------------------------------------------------------*/

        static void prvSwitchTimerLists( void )
        {
                TickType_t xNextExpireTime;
                List_t * pxTemp;

                /* The tick count has overflowed.    The timer lists must be switched.
                 * If there are any timers still referenced from the current timer list
                 * then they must have expired and should be processed before the lists
                 * are switched. */
                while( listLIST_IS_EMPTY( pxCurrentTimerList ) == pdFALSE )
                {
                        xNextExpireTime = listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxCurrentTimerList );

                        /* Process the expired timer.    For auto-reload timers, be careful to
                         * process only expirations that occur on the current list.    Further
                         * expirations must wait until after the lists are switched. */
                        prvProcessExpiredTimer( xNextExpireTime, tmrMAX_TIME_BEFORE_OVERFLOW );
                }

                pxTemp = pxCurrentTimerList;
                pxCurrentTimerList = pxOverflowTimerList;
                pxOverflowTimerList = pxTemp;
        }
/*-----------------------------------------------------------*/

        static void prvCheckForValidListAndQueue( void )
        {
                /* Check that the list from which active timers are referenced, and the
                 * queue used to communicate with the timer service, have been
                 * initialised. */
                taskENTER_CRITICAL();
                {
                        if( xTimerQueue == NULL )
                        {
                                vListInitialise( &xActiveTimerList1 );
                                vListInitialise( &xActiveTimerList2 );
                                pxCurrentTimerList = &xActiveTimerList1;
                                pxOverflowTimerList = &xActiveTimerList2;

                                #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
                                        {
                                                /* The timer queue is allocated statically in case
                                                 * configSUPPORT_DYNAMIC_ALLOCATION is 0. */
                                                PRIVILEGED_DATA static StaticQueue_t xStaticTimerQueue;                                                                                                                                                    /*lint !e956 Ok to declare in this manner to prevent additional conditional compilation guards in other locations. */
                                                PRIVILEGED_DATA static uint8_t ucStaticTimerQueueStorage[ ( size_t ) configTIMER_QUEUE_LENGTH * sizeof( DaemonTaskMessage_t ) ]; /*lint !e956 Ok to declare in this manner to prevent additional conditional compilation guards in other locations. */

                                                xTimerQueue = xQueueCreateStatic( ( UBaseType_t ) configTIMER_QUEUE_LENGTH, ( UBaseType_t ) sizeof( DaemonTaskMessage_t ), &( ucStaticTimerQueueStorage[ 0 ] ), &xStaticTimerQueue );
                                        }
                                #else
                                        {
                                                xTimerQueue = xQueueCreate( ( UBaseType_t ) configTIMER_QUEUE_LENGTH, sizeof( DaemonTaskMessage_t ) );
                                        }
                                #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */

                                #if ( configQUEUE_REGISTRY_SIZE > 0 )
                                        {
                                                if( xTimerQueue != NULL )
                                                {
                                                        vQueueAddToRegistry( xTimerQueue, "TmrQ" );
                                                }
                                                else
                                                {
                                                        mtCOVERAGE_TEST_MARKER();
                                                }
                                        }
                                #endif /* configQUEUE_REGISTRY_SIZE */
                        }
                        else
                        {
                                mtCOVERAGE_TEST_MARKER();
                        }
                }
                taskEXIT_CRITICAL();
        }
/*-----------------------------------------------------------*/

        BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer )
        {
                BaseType_t xReturn;
                Timer_t * pxTimer = xTimer;

                configASSERT( xTimer );

                /* Is the timer in the list of active timers? */
                taskENTER_CRITICAL();
                {
                        if( ( pxTimer->ucStatus & tmrSTATUS_IS_ACTIVE ) == 0 )
                        {
                                xReturn = pdFALSE;
                        }
                        else
                        {
                                xReturn = pdTRUE;
                        }
                }
                taskEXIT_CRITICAL();

                return xReturn;
        } /*lint !e818 Can't be pointer to const due to the typedef. */
/*-----------------------------------------------------------*/

        void * pvTimerGetTimerID( const TimerHandle_t xTimer )
        {
                Timer_t * const pxTimer = xTimer;
                void * pvReturn;

                configASSERT( xTimer );

                taskENTER_CRITICAL();
                {
                        pvReturn = pxTimer->pvTimerID;
                }
                taskEXIT_CRITICAL();

                return pvReturn;
        }
/*-----------------------------------------------------------*/

        void vTimerSetTimerID( TimerHandle_t xTimer,
                                                     void * pvNewID )
        {
                Timer_t * const pxTimer = xTimer;

                configASSERT( xTimer );

                taskENTER_CRITICAL();
                {
                        pxTimer->pvTimerID = pvNewID;
                }
                taskEXIT_CRITICAL();
        }
/*-----------------------------------------------------------*/

        #if ( INCLUDE_xTimerPendFunctionCall == 1 )

                BaseType_t xTimerPendFunctionCallFromISR( PendedFunction_t xFunctionToPend,
                                                                                                    void * pvParameter1,
                                                                                                    uint32_t ulParameter2,
                                                                                                    BaseType_t * pxHigherPriorityTaskWoken )
                {
                        DaemonTaskMessage_t xMessage;
                        BaseType_t xReturn;

                        /* Complete the message with the function parameters and post it to the
                         * daemon task. */
                        xMessage.xMessageID = tmrCOMMAND_EXECUTE_CALLBACK_FROM_ISR;
                        xMessage.u.xCallbackParameters.pxCallbackFunction = xFunctionToPend;
                        xMessage.u.xCallbackParameters.pvParameter1 = pvParameter1;
                        xMessage.u.xCallbackParameters.ulParameter2 = ulParameter2;

                        xReturn = xQueueSendFromISR( xTimerQueue, &xMessage, pxHigherPriorityTaskWoken );

                        tracePEND_FUNC_CALL_FROM_ISR( xFunctionToPend, pvParameter1, ulParameter2, xReturn );

                        return xReturn;
                }

        #endif /* INCLUDE_xTimerPendFunctionCall */
/*-----------------------------------------------------------*/

        #if ( INCLUDE_xTimerPendFunctionCall == 1 )

                BaseType_t xTimerPendFunctionCall( PendedFunction_t xFunctionToPend,
                                                                                     void * pvParameter1,
                                                                                     uint32_t ulParameter2,
                                                                                     TickType_t xTicksToWait )
                {
                        DaemonTaskMessage_t xMessage;
                        BaseType_t xReturn;

                        /* This function can only be called after a timer has been created or
                         * after the scheduler has been started because, until then, the timer
                         * queue does not exist. */
                        configASSERT( xTimerQueue );

                        /* Complete the message with the function parameters and post it to the
                         * daemon task. */
                        xMessage.xMessageID = tmrCOMMAND_EXECUTE_CALLBACK;
                        xMessage.u.xCallbackParameters.pxCallbackFunction = xFunctionToPend;
                        xMessage.u.xCallbackParameters.pvParameter1 = pvParameter1;
                        xMessage.u.xCallbackParameters.ulParameter2 = ulParameter2;

                        xReturn = xQueueSendToBack( xTimerQueue, &xMessage, xTicksToWait );

                        tracePEND_FUNC_CALL( xFunctionToPend, pvParameter1, ulParameter2, xReturn );

                        return xReturn;
                }

        #endif /* INCLUDE_xTimerPendFunctionCall */
/*-----------------------------------------------------------*/

        #if ( configUSE_TRACE_FACILITY == 1 )

                UBaseType_t uxTimerGetTimerNumber( TimerHandle_t xTimer )
                {
                        return ( ( Timer_t * ) xTimer )->uxTimerNumber;
                }

        #endif /* configUSE_TRACE_FACILITY */
/*-----------------------------------------------------------*/

        #if ( configUSE_TRACE_FACILITY == 1 )

                void vTimerSetTimerNumber( TimerHandle_t xTimer,
                                                                     UBaseType_t uxTimerNumber )
                {
                        ( ( Timer_t * ) xTimer )->uxTimerNumber = uxTimerNumber;
                }

        #endif /* configUSE_TRACE_FACILITY */
/*-----------------------------------------------------------*/

/* This entire source file will be skipped if the application is not configured
 * to include software timer functionality.    If you want to include software timer
 * functionality then ensure configUSE_TIMERS is set to 1 in FreeRTOSConfig.h. */
#endif /* configUSE_TIMERS == 1 */
